package com.atguigu.juc.sync;

import org.openjdk.jol.info.ClassLayout;

import java.util.concurrent.TimeUnit;

/**
 * @author yanglin
 * @create 2024-02-01 15:27 星期四
 * description:
 */
public class SynchronizedUpDemo2 {


    /**
     * 总结：
     *      当一个对象已经计算过 identity hash code 它就无法进入偏向锁状态，跳过偏向锁直接升级为轻量级锁
     *      偏向锁过程中遇到一致性hash计算请求，立马撤销偏向模式，膨胀为重量级锁
     * 锁的优缺点：
     *              优点                                  缺点                              使用场景
     *  偏向锁     加锁和解锁不需要额外消耗，和执行非      如果线程间存在锁竞争，会带来额外的        只有一个线程访问同步块     
     *            同步方法相比，仅存在纳秒级别的差距      锁撤销的消耗
     *  
     *  轻量级锁    竞争的线程不会阻塞，提高了程序的        如果始终得不到锁竞争的线程，使用        追求响应时间  同步块执行
     *             相应速度                             自旋会消耗CPU                        速度非常快
     *             
     * 重量级锁     线程间不适用自旋，不会消耗CPU          线程阻塞，响应时间缓慢               追求吞吐量  同步块执行时间较长
     *  
     */
    public static void main(String[] args) {
        //先睡5秒，保证开启偏向锁
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Object o = new Object();
        synchronized (o) {
            //此时，本来应该是偏向锁
            System.out.println("At this point,is should have been a biased lock");
            System.out.println(ClassLayout.parseInstance(o).toPrintable());
            o.hashCode();  
            //偏向锁过程中遇到一致性hash计算请求，立马撤销偏向模式，膨胀为重量级锁
            System.out.println("In the process of biased locking,when encountering a consistent has calculation request,the biased mode is immediately revoked, and it inflates into a heavyweight lock.");
            System.out.println(ClassLayout.parseInstance(o).toPrintable());
        }
    }

    //当一个对象已经计算过 identity hash code 它就无法进入偏向锁状态，跳过偏向锁直接升级为轻量级锁
    public static void m1() {
        //先睡5秒，保证开启偏向锁
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Object o = new Object();
        //此时，本来应该是偏向锁
        System.out.println("At this point,is should have been a biased lock");
        o.hashCode();   //没有重写，一致性hash，重写后无效，当一个对象已经计算过 identity hash code 它就无法进入偏向锁状态
        synchronized (o){
            //本应该是偏向锁，但是由于计算过一致性hash，会直接升级为轻量级锁
            System.out.println("It should have been a biased lock, but due to calculating consistent hash,it well be directly upgraded to a lightweight lock");
            System.out.println(ClassLayout.parseInstance(o).toPrintable());
        }
    }

}
